/*
  Name: DeadProxyClientPlayer.cpp
  Copyright:
  Author: Carl Chatfield
  Date: 12/02/08 14:20
  Description: Stores Player Data
*/

#include "DeadProxyClientPlayer.h"

void PlayerInfo::SetMaxHp(int MaxHp)
{
    player.MaxHp = MaxHp;
}

int PlayerInfo::GetMaxHp()
{
    return player.MaxHp;
}

void PlayerInfo::SetHp(int Hp)
{
    player.Hp = Hp;
}

int PlayerInfo::GetHp()
{
    return player.Hp;
}

void PlayerInfo::SetMaxMana(int MaxMana)
{
    player.MaxMana = MaxMana;
}

int PlayerInfo::GetMaxMana()
{
    return player.MaxMana;
}

void PlayerInfo::SetMana(int Mana)
{
    player.Mana = Mana;
}

int PlayerInfo::GetMana()
{
    return player.Mana;
}

void PlayerInfo::SetStamina(int Stamina)
{
    player.Stamina = Stamina;
}

int PlayerInfo::GetStamina()
{
    return player.Stamina;
}

void PlayerInfo::SetCap(int Cap)
{
    player.Cap = Cap;
}

int PlayerInfo::GetCap()
{
    return player.Cap;
}

void PlayerInfo::SetExp(int Exp)
{
    player.Exp = Exp;
}

int PlayerInfo::GetExp()
{
    return player.Exp;
}

void PlayerInfo::SetLevel(int Level)
{
    player.Level = Level;
}

int PlayerInfo::GetLevel()
{
    return player.Level;
}

void PlayerInfo::SetLevelPercent(int LevelPercent)
{
    player.LevelPercent = LevelPercent;
}

int PlayerInfo::GetLevelPercent()
{
    return player.LevelPercent;
}

void PlayerInfo::SetMagicLevel(int MagicLevel)
{
    player.MagicLevel = MagicLevel;
}

int PlayerInfo::GetMagicLevel()
{
    return player.MagicLevel;
}

void PlayerInfo::SetMagicLevelPercent(int MagicLevelPercent)
{
    player.MagicLevelPercent = MagicLevelPercent;
}

int PlayerInfo::GetMagicLevelPercent()
{
    return player.MagicLevelPercent;
}

void PlayerInfo::SetFist(int Fist)
{
    player.Fist = Fist;
}

int PlayerInfo::GetFist()
{
    return player.Fist;
}

void PlayerInfo::SetFistPercent(int FistPercent)
{
    player.FistPercent = FistPercent;
}

int PlayerInfo::GetFistPercent()
{
    return player.FistPercent;
}

void PlayerInfo::SetClub(int Club)
{
    player.Club = Club;
}

int PlayerInfo::GetClub()
{
    return player.Club;
}

void PlayerInfo::SetClubPercent(int ClubPercent)
{
    player.ClubPercent = ClubPercent;
}

int PlayerInfo::GetClubPercent()
{
    return player.ClubPercent;
}

void PlayerInfo::SetSword(int Sword)
{
    player.Sword = Sword;
}

int PlayerInfo::GetSword()
{
    return player.Sword;
}

void PlayerInfo::SetSwordPercent(int SwordPercent)
{
    player.SwordPercent = SwordPercent;
}

int PlayerInfo::GetSwordPercent()
{
    return player.SwordPercent;
}

void PlayerInfo::SetAxe(int Axe)
{
    player.Axe = Axe;
}

int PlayerInfo::GetAxe()
{
    return player.Axe;
}

void PlayerInfo::SetAxePercent(int AxePercent)
{
    player.AxePercent = AxePercent;
}

int PlayerInfo::GetAxePercent()
{
    return player.AxePercent;
}

void PlayerInfo::SetDistance(int Distance)
{
    player.Distance = Distance;
}

int PlayerInfo::GetDistance()
{
    return player.Distance;
}

void PlayerInfo::SetDistancePercent(int DistancePercent)
{
    player.DistancePercent = DistancePercent;
}

int PlayerInfo::GetDistancePercent()
{
    return player.DistancePercent;
}

void PlayerInfo::SetShielding(int Shielding)
{
    player.Shielding = Shielding;
}

int PlayerInfo::GetShielding()
{
    return player.Shielding;
}

void PlayerInfo::SetShieldingPercent(int ShieldingPercent)
{
    player.ShieldingPercent = ShieldingPercent;
}

int PlayerInfo::GetShieldingPercent()
{
    return player.ShieldingPercent;
}

void PlayerInfo::SetFishing(int Fishing)
{
    player.Fishing = Fishing;
}

int PlayerInfo::GetFishing()
{
    return player.Fishing;
}

void PlayerInfo::SetFishingPercent(int FishingPercent)
{
    player.FishingPercent = FishingPercent;
}

int PlayerInfo::GetFishingPercent()
{
    return player.FishingPercent;
}

void PlayerInfo::SetSoul(int Soul)
{
    player.Soul = Soul;
}

int PlayerInfo::GetSoul()
{
    return player.Soul;
}

void PlayerInfo::SetPlayerId(int PlayerId)
{
    player.PlayerId = PlayerId;
}

int PlayerInfo::GetPlayerId()
{
    return player.PlayerId;
}

void PlayerInfo::SetX(int x)
{
    player.x = x;
}

int PlayerInfo::GetX()
{
    return player.x;
}

void PlayerInfo::SetY(int y)
{
    player.y = y;
}

int PlayerInfo::GetY()
{
    return player.y;
}

void PlayerInfo::SetZ(int z)
{
    player.z = z;
}

int PlayerInfo::GetZ()
{
    return player.z;
}

void PlayerInfo::SetHeadSlot(Thing * HeadSlot)
{
    memcpy(&player.Equiptment[0], HeadSlot, sizeof(Thing));
    delete HeadSlot;
}

Thing * PlayerInfo::GetHeadSlot()
{
    return &player.Equiptment[0];
}

void PlayerInfo::SetArmorSlot(Thing * ArmorSlot)
{
    memcpy(&player.Equiptment[1], ArmorSlot, sizeof(Thing));
    delete ArmorSlot;
}

Thing * PlayerInfo::GetArmorSlot()
{
    return &player.Equiptment[1];
}

void PlayerInfo::SetLeftSlot(Thing * LeftSlot)
{
    memcpy(&player.Equiptment[2], LeftSlot, sizeof(Thing));
    delete LeftSlot;
}

Thing * PlayerInfo::GetLeftSlot()
{
    return &player.Equiptment[2];
}

void PlayerInfo::SetRightSlot(Thing * RightSlot)
{
    memcpy(&player.Equiptment[3], RightSlot, sizeof(Thing));
    delete RightSlot;
}

Thing * PlayerInfo::GetRightSlot()
{
    return &player.Equiptment[3];
}

void PlayerInfo::SetLegsSlot(Thing * LegsSlot)
{
    memcpy(&player.Equiptment[4], LegsSlot, sizeof(Thing));
    delete LegsSlot;
}

Thing * PlayerInfo::GetLegsSlot()
{
    return &player.Equiptment[4];
}

void PlayerInfo::SetFeetSlot(Thing * FeetSlot)
{
    memcpy(&player.Equiptment[5], FeetSlot, sizeof(Thing));
    delete FeetSlot;
}

Thing * PlayerInfo::GetFeetSlot()
{
    return &player.Equiptment[5];
}

void PlayerInfo::SetBackSlot(Thing * BackSlot)
{
    memcpy(&player.Equiptment[6], BackSlot, sizeof(Thing));
    delete BackSlot;
}

Thing * PlayerInfo::GetBackSlot()
{
    return &player.Equiptment[6];
}

void PlayerInfo::SetArrowSlot(Thing * ArrowSlot)
{
    memcpy(&player.Equiptment[7], ArrowSlot, sizeof(Thing));
    delete ArrowSlot;
}
Thing * PlayerInfo::GetArrowSlot()
{
    return &player.Equiptment[7];
}

void PlayerInfo::SetNeckSlot(Thing * NeckSlot)
{
    memcpy(&player.Equiptment[8], NeckSlot, sizeof(Thing));
    delete NeckSlot;
}

Thing * PlayerInfo::GetNeckSlot()
{
    return &player.Equiptment[8];
}

void PlayerInfo::SetRingSlot(Thing * RingSlot)
{
    memcpy(&player.Equiptment[9], RingSlot, sizeof(Thing));
    delete RingSlot;
}

Thing * PlayerInfo::GetRingSlot()
{
    return &player.Equiptment[9];
}

void PlayerInfo::SetStatus(unsigned short s)
{
    player.Status = s;
}

bool PlayerInfo::IsPoison()
{
    return player.Status & 0x0001;
}

bool PlayerInfo::IsFire()
{
    return player.Status & 0x0002;
}

bool PlayerInfo::IsEnergy()
{
    return player.Status & 0x0004;
}

bool PlayerInfo::IsDrunk()
{
    return player.Status & 0x0008;
}

bool PlayerInfo::IsManaShield()
{
    return player.Status & 0x0010;
}

bool PlayerInfo::IsParalyse()
{
    return player.Status & 0x0020;
}

bool PlayerInfo::IsHaste()
{
    return player.Status & 0x0040;
}

bool PlayerInfo::IsBattle()
{
    return player.Status & 0x0080;
}

bool PlayerInfo::IsWater()
{
    return player.Status & 0x0100;
}
